// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract MinimalERC20 {
    string public name = "Minimal Token";
    string public symbol = "MTK";
    uint8 public decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    constructor(uint256 _initialSupply) {
        totalSupply = _initialSupply * 10**18;
        balanceOf[msg.sender] = totalSupply;
        emit Transfer(address(0), msg.sender, totalSupply);
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor(uint256 initialSupply) ERC20("MyToken", "MTK") {
        _mint(msg.sender, initialSupply * 10**decimals());
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

contract AdvancedToken is ERC20, ERC20Burnable, ERC20Pausable, ERC20Capped, AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");

    constructor(uint256 cap) ERC20("Advanced", "ADV") ERC20Capped(cap * 10**18) {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
        _grantRole(PAUSER_ROLE, msg.sender);
    }

    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }

    function pause() external onlyRole(PAUSER_ROLE) {
        _pause();
    }

    function unpause() external onlyRole(PAUSER_ROLE) {
        _unpause();
    }

    function _update(address from, address to, uint256 value)
        internal override(ERC20, ERC20Pausable) {
        super._update(from, to, value);
    }

    function _maxMint()
        internal view override(ERC20Capped) returns (uint256) {
        return cap();
    }
}

contract MintableToken is ERC20, AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    uint256 public immutable cap;

    constructor(uint256 _cap) ERC20("Mintable", "MNT") {
        cap = _cap * 10**18;
        _grantRole(MINTER_ROLE, msg.sender);
    }

    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
        require(totalSupply() + amount <= cap, "Cap exceeded");
        _mint(to, amount);
    }

    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract SnapToken is ERC20Snapshot, Ownable {
    constructor() ERC20("SnapToken", "SNAP") {
        _mint(msg.sender, 1000000 * 10**18);
    }

    function takeSnapshot() external onlyOwner {
        snapshot();
    }

    function balanceAt(address account, uint256 snapshotId) external view returns (uint256) {
        return balanceOfAt(account, snapshotId);
    }

    function _update(address from, address to, uint256 amount)
        internal override(ERC20, ERC20Snapshot) {
        super._update(from, to, amount);
    }
}

// 简化版 Reflect Token _transfer 核心逻辑
function _transfer(address sender, address recipient, uint256 amount) internal {
    uint256 fee = amount * feeRate / 100;    // 5%交易费
    uint256 netAmount = amount - fee;          // 95%到账
    
    // 费用部分：反射余额减少但真实余额不变
    _rBalances[sender] -= amount * currentRate;
    _rBalances[recipient] += netAmount * currentRate;
    // 费率更新：rSupply下降 → rate下降 → 所有持币者tBalance自动增长
}

// IERC20 核心接口（示意）
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// IERC721 核心接口（示意）
interface IERC721 {
    function balanceOf(address owner) external view returns (uint256);
    function ownerOf(uint256 tokenId) external view returns (address);
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function transferFrom(address from, address to, uint256 tokenId) external;
    function approve(address to, uint256 tokenId) external;
    function setApprovalForAll(address operator, bool approved) external;
    function getApproved(uint256 tokenId) external view returns (address);
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

_owners[tokenId]          → address       // tokenId 的当前所有者
_tokenApprovals[tokenId]  → address       // 被批准转移该 tokenId 的地址
_operatorApprovals[owner][operator] → bool // operator 是否被 owner 批量授权

// OpenZeppelin 风格的 ERC-721 接口定义片段
abstract contract ERC721Basic {
    // 内部存储
    mapping(uint256 => address) private _owners;
    mapping(address => uint256) private _balances;
    mapping(uint256 => address) private _tokenApprovals;
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

    function balanceOf(address owner) public view virtual returns (uint256) {
        require(owner != address(0), "ERC721: address zero");
        return _balances[owner];
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyNFT is ERC721Enumerable, ERC721URIStorage, Ownable {
    uint256 private _nextTokenId;

    constructor() ERC721("MyNFT Collection", "MNFT") Ownable(msg.sender) {}

    function _baseURI() internal pure override returns (string memory) {
        return "https://gateway.pinata.cloud/ipfs/QmBase/";
    }

    function safeMint(address to, string memory uri) public onlyOwner returns (uint256) {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
        return tokenId;
    }

    // 重写 required overrides
    function _update(address to, uint256 tokenId, address auth)
        internal override(ERC721, ERC721Enumerable, ERC721URIStorage) returns (address)
    {
        return super._update(to, tokenId, auth);
    }

    function _increaseBalance(address account, uint128 value)
        internal override(ERC721, ERC721Enumerable)
    {
        super._increaseBalance(account, value);
    }

    function tokenURI(uint256 tokenId)
        public view override(ERC721, ERC721URIStorage) returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public view override(ERC721, ERC721Enumerable) returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

// IERC721Receiver 接口实现示例
contract NFTHolder is IERC721Receiver {
    mapping(uint256 => address) public tokenToOriginalOwner;

    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external override returns (bytes4) {
        tokenToOriginalOwner[tokenId] = from;
        return this.onERC721Received.selector;
    }
}

# IPFS 命令行示例
$ ipfs add example.jpg
# 输出: added QmXoypizjW3WknFiJnKLwHCnL72vedxjQkDDP1mXWo6uco example.jpg

# 通过公共 Gateway 访问
# https://ipfs.io/ipfs/QmXoypizjW3WknFiJnKLwHCnL72vedxjQkDDP1mXWo6uco

{
  "name": "CyberPunk #0420",
  "description": "一个来自 CyberPunk 宇宙的稀有角色。拥有金色皮肤和霓虹光环。",
  "image": "https://gateway.pinata.cloud/ipfs/QmRnxCp7KJS3X6QkR8N2dVJzTvGzSdPwL1Z4qXkLMwJ9Yq",
  "attributes": [
    { "trait_type": "皮肤", "value": "金色" },
    { "trait_type": "背景", "value": "霓虹蓝" },
    { "trait_type": "装备", "value": "激光剑" },
    { "trait_type": "稀有度", "value": "传说" }
  ],
  "animation_url": "https://gateway.pinata.cloud/ipfs/Qm...glb",
  "external_url": "https://cyberpunknft.io/0420"
}

// Node.js 使用 @pinata/sdk 上传图片与元数据
import pinataSDK from '@pinata/sdk';
import fs from 'fs';
import path from 'path';

const pinata = new pinataSDK({ pinataJWTKey: process.env.PINATA_JWT });

async function uploadNFTMetadata(tokenId, imagePath, attributes) {
    // Step 1: 上传图片
    const imageStream = fs.createReadStream(imagePath);
    const imgResult = await pinata.pinFileToIPFS(imageStream, {
        pinataMetadata: { name: `nft_${tokenId}_image` }
    });
    const imageUrl = `https://gateway.pinata.cloud/ipfs/${imgResult.IpfsHash}`;

    // Step 2: 构建并上传元数据 JSON
    const metadata = {
        name: `MyNFT #${tokenId}`,
        description: `MyNFT Collection 的第 ${tokenId} 号作品`,
        image: imageUrl,
        attributes
    };
    const metaResult = await pinata.pinJSONToIPFS(metadata, {
        pinataMetadata: { name: `nft_${tokenId}_metadata` }
    });
    const metadataUrl = `https://gateway.pinata.cloud/ipfs/${metaResult.IpfsHash}`;

    return { tokenId, imageCid: imgResult.IpfsHash, metadataCid: metaResult.IpfsHash, metadataUrl };
}

// 批量上传 100 个 NFT 元数据脚本
import pinataSDK from '@pinata/sdk';
import fs from 'fs';
import path from 'path';

const pinata = new pinataSDK({ pinataJWTKey: process.env.PINATA_JWT });
const IMAGE_DIR = './images';
const cidMap = [];

async function uploadWithRetry(fn, retries = 3) {
    for (let i = 0; i < retries; i++) {
        try {
            return await fn();
        } catch (e) {
            if (i === retries - 1) throw e;
            console.log(`重试第 ${i + 1} 次...`);
            await new Promise(r => setTimeout(r, 2000));
        }
    }
}

async function batchUpload() {
    for (let i = 0; i < 100; i++) {
        const imageFile = path.join(IMAGE_DIR, `token_${i}.png`);
        if (!fs.existsSync(imageFile)) {
            console.warn(`跳过缺失文件: ${imageFile}`);
            continue;
        }

        // 上传图片
        const imgResult = await uploadWithRetry(() =>
            pinata.pinFileToIPFS(fs.createReadStream(imageFile), {
                pinataMetadata: { name: `token_${i}_image` }
            })
        );
        const imageUrl = `https://gateway.pinata.cloud/ipfs/${imgResult.IpfsHash}`;

        // 上传元数据
        const metadata = {
            name: `NFT #${i}`,
            description: `批量生成的 NFT 第 ${i} 号`,
            image: imageUrl,
            attributes: [
                { trait_type: "系列编号", value: i.toString() }
            ]
        };
        const metaResult = await uploadWithRetry(() =>
            pinata.pinJSONToIPFS(metadata, {
                pinataMetadata: { name: `token_${i}_metadata` }
            })
        );

        cidMap.push({
            tokenId: i,
            imageCid: imgResult.IpfsHash,
            metadataCid: metaResult.IpfsHash,
            metadataUrl: `https://gateway.pinata.cloud/ipfs/${metaResult.IpfsHash}`
        });

        console.log(`[{i + 1}/100] 完成 token_{i}`);
    }

    // 导出 CID 映射表
    fs.writeFileSync('cid_map.json', JSON.stringify(cidMap, null, 2));
    console.log('所有上传完成！CID 映射表已保存至 cid_map.json');
}

batchUpload().catch(console.error);

// JavaScript 示例：使用 merkletreejs 构建 Merkle 树并生成证明
const { MerkleTree } = require('merkletreejs');
const keccak256 = require('keccak256');

const whitelist = [
  '0x5B38Da6a701c568545dCfcB03FcB875f56beddC4',
  '0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2',
  '0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db',
  '0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB'
];

const leaves = whitelist.map(addr => keccak256(addr));
const tree = new MerkleTree(leaves, keccak256, { sortPairs: true });
const root = tree.getRoot().toString('hex');

// 为用户生成 Merkle Proof（传给合约的 bytes32[]）
const leaf = keccak256(whitelist[0]);
const proof = tree.getHexProof(leaf);
console.log('Merkle Root:', root);
console.log('Proof for A:', proof);

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

typealias WhitelistNFT is ERC721;

contract WhitelistMinter is ERC721 {
    bytes32 public merkleRoot;
    mapping(address => bool) private _whitelistMinted;
    bool public whitelistOpen;
    bool public publicMintOpen;
    uint256 public wlPrice = 0.05 ether;
    uint256 public publicPrice = 0.08 ether;
    uint256 public maxSupply = 10000;
    uint256 public totalMinted;

    constructor(string memory name, string memory symbol, bytes32 _merkleRoot)
        ERC721(name, symbol)
    {
        merkleRoot = _merkleRoot;
    }

    function setWhitelistOpen(bool open) external onlyOwner {
        whitelistOpen = open;
    }

    function setPublicMintOpen(bool open) external onlyOwner {
        publicMintOpen = open;
    }

    function whitelistMint(bytes32[] calldata merkleProof) external payable {
        require(whitelistOpen, "Whitelist phase not active");
        require(!_whitelistMinted[msg.sender], "Already minted on whitelist");
        require(msg.value == wlPrice, "Incorrect whitelist price");
        require(totalMinted < maxSupply, "Sold out");

        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(
            MerkleProof.verify(merkleProof, merkleRoot, leaf),
            "Invalid whitelist proof"
        );

        _whitelistMinted[msg.sender] = true;
        totalMinted++;
        _safeMint(msg.sender, totalMinted);
    }

    function publicMint() external payable {
        require(publicMintOpen, "Public mint not active");
        require(msg.value == publicPrice, "Incorrect public price");
        require(totalMinted < maxSupply, "Sold out");
        totalMinted++;
        _safeMint(msg.sender, totalMinted);
    }

    // onlyOwner modifier and withdraw function omitted for brevity
}

contract BlindBoxNFT is ERC721 {
    string private _unrevealedURI;
    string private _baseTokenURI;
    bool public revealed;
    uint256 public totalSupply;
    uint256 public constant MAX_SUPPLY = 10000;

    constructor(string memory unrevealed) ERC721("BlindBox", "BB") {
        _unrevealedURI = unrevealed;
    }

    function mint() external payable {
        require(totalSupply < MAX_SUPPLY, "Sold out");
        totalSupply++;
        _safeMint(msg.sender, totalSupply);
    }

    function _baseURI() internal view override returns (string memory) {
        if (!revealed) {
            return "";
        }
        return _baseTokenURI;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        _requireOwned(tokenId);
        if (!revealed) {
            return _unrevealedURI;
        }
        return string(abi.encodePacked(_baseTokenURI, _toString(tokenId), ".json"));
    }

    function reveal(string memory newBaseURI) external onlyOwner {
        require(!revealed, "Already revealed");
        _baseTokenURI = newBaseURI;
        revealed = true;
    }

    function _toString(uint256 value) internal pure returns (string memory) {
        // Simplified toString for illustration
        if (value == 0) return "0";
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) { digits++; temp /= 10; }
        bytes memory buffer = new bytes(digits);
        while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; }
        return string(buffer);
    }
}

contract RateLimitedMinter is ERC721 {
    uint256 public constant MAX_SUPPLY = 10000;
    uint256 public constant MAX_PER_WALLET = 3;
    uint256 public totalSupply;
    mapping(address => uint256) public mintedPerWallet;
    uint256 public cost = 0.05 ether;

    function mint(uint256 amount) external payable {
        require(totalSupply + amount <= MAX_SUPPLY, "Exceeds max supply");
        require(
            mintedPerWallet[msg.sender] + amount <= MAX_PER_WALLET,
            "Exceeds per-wallet limit"
        );
        require(msg.value == cost * amount, "Incorrect ETH amount");

        for (uint256 i = 0; i < amount; i++) {
            totalSupply++;
            _safeMint(msg.sender, totalSupply);
        }
        mintedPerWallet[msg.sender] += amount;
    }
}

// React + ethers.js v6 钱包连接与合约实例化示例
import { BrowserProvider, Contract } from 'ethers';
import { useState, useEffect } from 'react';

const CONTRACT_ADDRESS = '0xYourContractAddress';
const ABI = [
  // 简化 ABI，实际应导出完整 ABI
  "function totalSupply() view returns (uint256)",
  "function mint() payable",
  "function whitelistMint(bytes32[] calldata) payable",
  "function cost() view returns (uint256)",
  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
];

function useContract(signerOrProvider) {
  return new Contract(CONTRACT_ADDRESS, ABI, signerOrProvider);
}

function useWallet() {
  const [address, setAddress] = useState(null);
  const [provider, setProvider] = useState(null);
  const [signer, setSigner] = useState(null);

  async function connect() {
    if (!window.ethereum) return alert('请安装 MetaMask');
    const _provider = new BrowserProvider(window.ethereum);
    await _provider.send('eth_requestAccounts', []);
    const _signer = await _provider.getSigner();
    const _address = await _signer.getAddress();
    setProvider(_provider);
    setSigner(_signer);
    setAddress(_address);
  }

  return { address, provider, signer, connect };
}

export { useContract, useWallet };

// React 铸造函数示例
import { useState } from 'react';
import { useWallet, useContract }  from './useWallet';
import { MerkleTree } from 'merkletreejs';
import keccak256 from 'keccak256';

// 由项目方提供的白名单列表（实际可从后端 API 获取）
const WHITELIST = ['0x5B38Da6a701c...', '0xAb8483F64d9C...'];

function MintButton({ quantity, isWhitelistPhase }) {
  const { address, signer } = useWallet();
  const [status, setStatus] = useState('idle');

  async function handleMint() {
    if (!signer || !address) return;
    const contract = useContract(signer);
    setStatus('pending');

    try {
      let tx;
      if (isWhitelistPhase) {
        const leaves = WHITELIST.map(a => keccak256(a));
        const tree = new MerkleTree(leaves, keccak256, { sortPairs: true });
        const leaf = keccak256(address);
        const proof = tree.getHexProof(leaf);
        tx = await contract.whitelistMint(proof, { value: await contract.wlPrice() });
      } else {
        tx = await contract.mint({ value: await contract.cost() });
      }
      await tx.wait();
      setStatus('success');
    } catch (err) {
      console.error(err);
      setStatus('failed');
    }
  }

  return (
    <div>
      <button onClick={handleMint} disabled={status === 'pending'}>
        {status === 'pending' ? '铸造中...' : '立即铸造'}
      </button>
      {status === 'success' && <p style={{color: 'green'}}>铸造成功！</p>}
      {status === 'failed' && <p style={{color: 'red'}}>铸造失败，请重试。</p>}
    </div>
  );
}

// 自定义 useNFTs Hook：获取用户藏品列表
import { useState, useEffect } from 'react';
import { useWallet, useContract } from './useWallet';

function useNFTs() {
  const { address, provider } = useWallet();
  const [nfts, setNfts] = useState([]);
  const [loading, setLoading] = useState(false);

  useEffect(() => {
    if (!address || !provider) return;

    async function loadNFTs() {
      setLoading(true);
      try {
        const contract = useContract(provider);
        const balance = Number(await contract.balanceOf(address));
        if (balance === 0) { setNfts([]); return; }

        const tokenIds = [];
        for (let i = 0; i < balance; i++) {
          const tokenId = await contract.tokenOfOwnerByIndex(address, i);
          tokenIds.push(Number(tokenId));
        }

        // 并发获取 tokenURI 与元数据，分 10 个一批
        const batchSize = 10;
        const metadataList = [];
        for (let i = 0; i < tokenIds.length; i += batchSize) {
          const batch = tokenIds.slice(i, i + batchSize);
          const batchResults = await Promise.all(
            batch.map(async (id) => {
              const uri = await contract.tokenURI(id);
              const httpsUri = uri.replace('ipfs://', 'https://gateway.pinata.cloud/ipfs/');
              const res = await fetch(httpsUri);
              const meta = await res.json();
              return { id, ...meta, image: meta.image?.replace('ipfs://', 'https://gateway.pinata.cloud/ipfs/') };
            })
          );
          metadataList.push(...batchResults);
        }
        setNfts(metadataList);
      } catch (e) {
        console.error('加载藏品失败', e);
      } finally {
        setLoading(false);
      }
    }

    loadNFTs();
  }, [address, provider]);

  return { nfts, loading };
}

export default useNFTs;

// Merkle 树生成与按地址导出 proof 的 Node.js 工具脚本
const fs = require('fs');
const { MerkleTree } = require('merkletreejs');
const keccak256 = require('keccak256');

const whitelist = JSON.parse(fs.readFileSync('./whitelist.json', 'utf-8'));
const leaves = whitelist.map(addr => keccak256(addr));
const tree = new MerkleTree(leaves, keccak256, { sortPairs: true });
const root = tree.getHexRoot();

fs.writeFileSync('./merkleRoot.json', JSON.stringify({ root }, null, 2));

const proofs = {};
for (const addr of whitelist) {
  const leaf = keccak256(addr);
  proofs[addr] = tree.getHexProof(leaf);
}

fs.mkdirSync('./proofs', { recursive: true });
for (const [addr, proof] of Object.entries(proofs)) {
  fs.writeFileSync(`./proofs/${addr}.json`, JSON.stringify({ proof }, null, 2));
}

console.log('Merkle Root:', root);
console.log('Proofs generated for', whitelist.length, 'addresses.');

// 前端根据地址从静态 JSON 获取 proof 并铸造
async function getWhitelistProof(address) {
  try {
    const res = await fetch(`/proofs/${address}.json`);
    if (!res.ok) return null;
    const data = await res.json();
    return data.proof; // bytes32[] 格式
  } catch {
    return null;
  }
}

// 漏洞合约 —— 不要在生产环境使用！
contract VulnerableMint {
    mapping(address => uint256) public userDeposits;
    uint256 public tokenId;
    NFT public nft;

    // ❌ 危险：先执行外部调用（transfer），再更新状态
    function mintWithRefund() external payable {
        require(msg.value >= 0.01 ether, "Insufficient");
        uint256 id = ++tokenId;
        
        // 危险点：先执行外部调用
        (bool success, ) = msg.sender.call{value: msg.value}("");
        require(success, "Transfer failed");
        
        // 状态更新在外部调用之后 —— 可被重入绕过
        userDeposits[msg.sender] += msg.value;
        nft.mint(msg.sender, id);
    }
}

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract SafeMint is ReentrancyGuard {
    mapping(address => uint256) public userDeposits;
    uint256 public tokenId;
    NFT public nft;

    // ✅ 安全：检查 → 更新状态 → 外部交互
    function mintWithRefund() external payable nonReentrant {
        require(msg.value >= 0.01 ether, "Insufficient");
        
        // 1. Checks（检查）
        uint256 id = ++tokenId;
        // 2. Effects（更新状态）
        userDeposits[msg.sender] += msg.value;
        nft.mint(msg.sender, id);
        // 3. Interactions（外部交互）
        (bool success, ) = msg.sender.call{value: msg.value}("");
        require(success, "Transfer failed");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Base64.sol";

contract SecureNFT is ERC721, ReentrancyGuard, AccessControl {
    using Strings for uint256;

    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
    bytes32 public constant URI_MANAGER_ROLE = keccak256("URI_MANAGER_ROLE");

    uint256 private _tokenIdCounter;
    string private _baseTokenURI;

    constructor(string memory name, string memory symbol, string memory baseURI)
        ERC721(name, symbol)
    {
        _baseTokenURI = baseURI;
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
        _grantRole(URI_MANAGER_ROLE, msg.sender);
    }

    function safeMint(address to) external onlyRole(MINTER_ROLE) nonReentrant {
        require(to != address(0), "ERC721: mint to zero address");
        uint256 tokenId = _tokenIdCounter;
        _tokenIdCounter++;
        _safeMint(to, tokenId);
    }

    function batchMint(address to, uint256 amount)
        external
        onlyRole(MINTER_ROLE)
        nonReentrant
    {
        require(to != address(0), "ERC721: mint to zero address");
        require(amount > 0 && amount <= 20, "Batch too large");
        for (uint256 i = 0; i < amount; i++) {
            uint256 tokenId = _tokenIdCounter;
            _tokenIdCounter++;
            _safeMint(to, tokenId);
        }
    }

    function setBaseURI(string calldata newBaseURI)
        external
        onlyRole(URI_MANAGER_ROLE)
    {
        _baseTokenURI = newBaseURI;
    }

    function _baseURI() internal view override returns (string memory) {
        return _baseTokenURI;
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, AccessControl)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

// Hardhat 测试脚本：Gas 测量
const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Gas Comparison", function () {
    async function measure(contract, amount) {
        const tx = await contract.batchMint(
            ethers.constants.AddressZero.replace(/.$/, "1"), amount
        );
        const receipt = await tx.wait();
        return receipt.gasUsed.toNumber();
    }

    it("should log gas for 1/5/10/100 mints", async function () {
        const Standard = await ethers.getContractFactory("StandardERC721");
        const AzukiA = await ethers.getContractFactory("AzukiERC721A");
        const std = await Standard.deploy();
        const az = await AzukiA.deploy();
        await std.deployed();
        await az.deployed();

        for (const n of [1, 5, 10, 100]) {
            const g1 = await measure(std, n);
            const g2 = await measure(az, n);
            console.log(`Mint ${n}: Standard=${g1}, 721A=${g2}, Saved=${((g1-g2)/g1*100).toFixed(1)}%`);
        }
    });
});

// ethers.js 计算 CREATE2 地址
const { ethers } = require("ethers");
const factoryAddress = "0x4e59b44847b379578588920cA78FbF26c0B4956C"; // CREATE2 工厂
const salt = ethers.id("MY_NFT_SALT_2024"); // 统一盐值
const bytecode = require("../artifacts/contracts/MyNFT.sol/MyNFT.json").bytecode;
const initCodeHash = ethers.keccak256(bytecode);

const predictedAddress = ethers.getCreate2Address(
    factoryAddress,
    salt,
    initCodeHash
);
console.log("跨链统一地址:", predictedAddress);

// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");
require("@nomicfoundation/hardhat-verify");
require("dotenv").config();

const PRIVATE_KEY = process.env.PRIVATE_KEY;
const ALCHEMY_KEY = process.env.ALCHEMY_API_KEY;

module.exports = {
    solidity: "0.8.20",
    networks: {
        sepolia: {
            url: `https://eth-sepolia.g.alchemy.com/v2/${ALCHEMY_KEY}`,
            accounts: [PRIVATE_KEY],
            chainId: 11155111,
        },
        polygon: {
            url: `https://polygon-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}`,
            accounts: [PRIVATE_KEY],
            chainId: 137,
        },
        arbitrum: {
            url: `https://arb-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}`,
            accounts: [PRIVATE_KEY],
            chainId: 42161,
        },
    },
    etherscan: {
        apiKey: {
            sepolia: process.env.ETHERSCAN_API_KEY,
            polygon: process.env.POLYGONSCAN_API_KEY,
            arbitrum: process.env.ARBISCAN_API_KEY,
        },
    },
};

// scripts/deploy.js
const { ethers, run, network } = require("hardhat");
const fs = require("fs");

async function deploy(contractName, args = []) {
    console.log(`\n🚀 正在部署到: ${network.name} (chainId=${network.config.chainId})`);
    
    const ContractFactory = await ethers.getContractFactory(contractName);
    const contract = await ContractFactory.deploy(...args);
    await contract.deployed();
    
    console.log(`✅ 合约地址: ${contract.address}`);
    console.log(`🔍 交易哈希: ${contract.deployTransaction.hash}`);
    
    // 等待区块确认后自动验证
    if (network.config.chainId !== 31337) {
        console.log("⏳ 等待 6 个区块确认...");
        await contract.deployTransaction.wait(6);
        
        try {
            await run("verify:verify", {
                address: contract.address,
                constructorArguments: args,
            });
            console.log("✅ 源码验证成功！");
        } catch (e) {
            console.log("⚠️ 验证失败或已自动验证:", e.message);
        }
    }
    
    // 记录部署日志
    const log = {
        network: network.name,
        chainId: network.config.chainId,
        contractName,
        address: contract.address,
        txHash: contract.deployTransaction.hash,
        timestamp: new Date().toISOString(),
    };
    const logPath = `./deployments/${network.name}.json`;
    fs.mkdirSync("./deployments", { recursive: true });
    fs.writeFileSync(logPath, JSON.stringify(log, null, 2));
    
    return contract;
}

async function main() {
    const nft = await deploy("SecureNFT", ["MyCollection", "MYC", "ipfs://.../"]);
}

main().catch((error) => {
    console.error(error);
    process.exit(1);
});

// utils/switchNetwork.ts
import { ExternalProvider } from "@ethersproject/providers";

export async function switchToPolygon(): Promise<void> {
    const provider = (window as any).ethereum as ExternalProvider;
    if (!provider?.request) throw new Error("MetaMask 未安装");

    const polygonChainId = "0x89"; // 137 in hex
    
    try {
        await provider.request({
            method: "wallet_switchEthereumChain",
            params: [{ chainId: polygonChainId }],
        });
    } catch (switchError: any) {
        // 该链未在钱包中添加
        if (switchError.code === 4902) {
            await provider.request({
                method: "wallet_addEthereumChain",
                params: [{
                    chainId: polygonChainId,
                    chainName: "Polygon Mainnet",
                    rpcUrls: ["https://polygon-rpc.com"],
                    nativeCurrency: {
                        name: "MATIC",
                        symbol: "MATIC",
                        decimals: 18,
                    },
                    blockExplorerUrls: ["https://polygonscan.com"],
                }],
            });
        } else {
            throw switchError;
        }
    }
}

// wagmi.ts
import { createConfig, http } from "wagmi";
import { mainnet, polygon, arbitrum, sepolia } from "wagmi/chains";
import { injected } from "wagmi/connectors";

export const config = createConfig({
    chains: [mainnet, polygon, arbitrum, sepolia],
    connectors: [injected()],
    transports: {
        [mainnet.id]: http(),
        [polygon.id]: http(),
        [arbitrum.id]: http(),
        [sepolia.id]: http(),
    },
});

// 多网络合约地址映射
export const CONTRACT_ADDRESS: Record<number, `0x${string}`> = {
    [mainnet.id]: "0x1234...",
    [polygon.id]: "0x5678...",
    [arbitrum.id]: "0x9abc...",
    [sepolia.id]: "0xdef0...",
};

// 组件中使用
import { useNetwork, useSwitchChain, useAccount } from "wagmi";

function NetworkSwitcher() {
    const { chain } = useNetwork();
    const { switchChain } = useSwitchChain();
    const desiredChainId = polygon.id;

    if (chain?.id !== desiredChainId) {
        return (
            <button onClick={() => switchChain?.({ chainId: desiredChainId })}>
                切换至 Polygon 网络
            </button>
        );
    }
    return <span>✅ 已连接 Polygon</span>;
}